New Star Software Collection/NSS_Collection.iso/3-069 qemm 603/1.ima/DVMAN/CH7.DEV

Text File | 1991-10-08 | 51.1 KB | 1,193 lines

Chapter 7

Changing a Program's Information

 The Change a Program menu gives you access to the complete set
of information that DESQview has for a program ~dash~ in two
screens. This is the information that is read in from/written out
to the .DVP file DESQview requires to run the program. The first
screen shows the basic information about the program. The second
screen shows the advanced program information.

~Heading~ Telling DESQview About a Program

 For DESQview to run a program, it needs to know something about
the program. At a mimimum, DESQview needs to know where the
program is stored, the DOS command that starts it up, and how
much memory it needs. Also, there are additional settings you can
use to configure the program more precisely.

~Subhead~ The Add a Program Command

 You install a program using the Add a Program command (see pages
62-63). To make this as easy as possible, DESQview comes with all
the necessary information (except where the program is stored)
already set up for many popular programs. All you need do is tell
DESQview which programs you want.

~Subhead~ Understanding How DESQview Runs a Program

 All DESQview's knowledge about the programs on the Add a Program
menu is contained inthe file, DESQVIEW.DIR. When you install a
program, DESQview extracts the relevant information from this
file and creates a DESQview Program Information File (DVP), named
xx- PIF.DVP, that it stores on the drive and directory from which
you started DESQview (most commonly, C:\DV) ~dash~ where xx are
the keys you use to select the program on the Open Window menu.

DESQview also comes with special "loaders" that permit many of
the popular programs that are "misbehaved" to run in small
windows and in background anyway (see page 112). "Loaders" have
the name xx-LOAD.COM, and are automatically copied onto your hard
disk for you when you install DESQview.

Each time you select a program to start up from the Open Window
menu, DESQview reads its DVP to determine how to configure it and
what DOS command to use to start it up. If the program has a
"loader," that "loader" is used automatically to load the program
(unless you override it).

If the program you want to install isn't listed on the Add a
Program menu, install it using the Add OTHER Program command (see
Adding A program, Chapter 3). You can use a Program Information
File (PIF), if you have one. If not, just enter the necessary
information.

~Subhead~ The Change a Program Command

 The Change a Program command lets you edit the information in a
program's DVP. Just display the Change a Program menu and make
the changes you want. When you press <Enter>, to indicate you're
finished, the current DVP is saved with the extension BAK and
then the program's DVP is updated to reflect the changes you
made. The changes you make don't take effect until the next time
you start up the program ~dash~ they don't apply to any instances
of the program that are currently running.

~Heading~ Overview of the Change a Program Screens

 Change a Program consists of two screens of data and 15 options
that you can turn ON or OFF (by entering Y or N in the space
provided next to the option's name). They group into five overall
factors that you can control for a program:

~Item~ What appears on the Open Window menu for the program.

~Item~ What DOS command is used to start up the program.

~Item~ How memory is allocated for the program.

~Item~ How the program behaves as you run it in DESQview.

~Item~ How the program behaves on an 80386 PC with QEMM-386
(DESQview386).

The most important information is listed on the first (basic)
screen. As a rule, you don't need to be concerned about the
information on the second (advanced) screen. It's primarily used
to fine tune how your program runs in DESQview and by the program
developer who preconfigured the program for you.

~Subhead~ Conventions

 The remainder of this chapter discusses the factors listed
above. To help you find the description of a particular field or
option:

 Entries that appear in the form Program Name identify the major
description of a particular field or option on the first (basic)
Change a Program screen.     Entries that appear in the form
Initial Mode identify the major description of a particular field
or option on the second (advanced) Change a Program screen.

~Subhead~ Creating an Open Window Menu Entry

 The entry that appears on the Open Window menu for a program is
defined by:

 The Program Name field, which specifies whatever text you wantup
to 30 characters long. This is also the name that appears on the
top frame bar of the program's window when the program is
running.  The Keys to Use on Open Menu field, which specifies the
keys you want to use to select the program. The keys should
consist of either one or two characters.  (We recommend you use
two characters to avoid future naming conflicts.) The keys you
pick must be different from any that are currently listed.
These keys also define the file names DESQview uses for files
related to the program (also see Appendix G):    ~dash~  xx-
PIF.DVP is the program's DESQview Program Information File (DVP).

 ~dash~  xx-SCRIP.DVS is the program's scripts file ~dash~ if
any.

 ~dash~  xx-LOAD.COM is the program's "loader" (customization
file) ~dash~ if any.

~Heading~ Starting Up a Program

 Perhaps the most important information you must supply DESQview
about a program is how to start it up:

 The Program field specifies the  DOS command used to start up
the program. Basically, you should enter  the command you type to
DOS to start up the program outside of DESQview,  preceded by the
path (drive and directory) where the program  is storednamely,
P:\ProgDir\Program. However, the exact  form entered determines:
~dash~  Whether DOS or DESQview will load the program.

 ~dash~  Whether a special DESQview "loader" will be used to load
the program.

 ~dash~  Whether you're creating a DOS window rather than loading
a program.

 The remainder of this section, Starting Up a Program, discusses
this.

 The Parameters field specifies any  additional information you
want to supply to the program when you  start it up. So,
effectively, the Program field appears to the program  as if it
also containsParameters. To supply  variable information, enter ?
as the last character.  DESQview will pause and let you manually
complete the command before  it loads the program. The Directory
field specifies the path on which you've stored the  data files
for the program. If this is the same as the path where  you've
stored the program, you can omit the path in the Program field.
If you leave the Directory field empty, the program's data files
are assumed to be on the path from which you started DESQview
(most commonly, C:\DV). So, as a rule, you should always specify
a path in the Directory field.

 Some programs require that the default path be the one on which
the program is stored to work properly. Programs that use
overlays often require this. In such cases, you must specify
P:\ProgDir in the Directory field and cannot specify a separate
D:\DataDir data path.

When you install a program, the Path field information you
specify on the Program Location menu (see step 4 on page 63) or
on the Add OTHER Program menu (see step 2 on page 64) is entered
in the Directory field rather than in the Program field. This
allows the program to operate properly in the most common case
~dash~  when the program and its data files are both on the same
path. However, if the program is on a different path than its
data files, you must manually modify the Program and Directory
fields to reflect this.

 The Program, Parameters, and Directory fields can each be up to
64 characters long.

~Subhead~ Controlling How a Program is Loaded

 Given that your system and the Change a Program menu for the
program are configured as shown below:

~Begin Table~

Path in effect when you started up DESQview - InitialPath
Path where DESQview is stored -  C:\DV

Contents of the Program field  -  P:\ProgDir\Program
Contents of the Parameters field -  Parameters
Contents of the Directory field  - D:\DataDir

~End Table~

DESQview loads and runs the program by logically performing the
following sequence of DOS commands:

1. PATH InitialPath; C:\DV; P:\ProgDir <Enter>
2. D: <Enter>
3. CD\DataDir <Enter>
4. Program (+ Parameters , if any)<Enter>

If D: or \DataDir is omitted, the corresponding command (2 or 3)
is omitted. If you omit the contents of the Directory field
(D:\DataDir) completely, the default path will be the path at the
time you started DESQview (most commonly, C:\DV). If DESQview
~dash~ rather than DOS (see below) ~dash~  loads the program, the
PATH command (1) is not performed ~dash~ the program must be
stored on P:\ProgDir or C:\DV or DESQview won't find the
executable file.

~Subhead~ When DOS Loadsa Program

 Whether a program is loaded by DOS or by DESQview is determined
by the format of the program file name in the Program field. If
the file name does not have an extension ~dash~ for example, 123
~dash~ DOS is started up and used to load the program. DOS is
started up by loading the file COMMAND.COM, which must be in the
root directory of the drive from which you started DESQview.

Using COMMAND.COM has the advantage that you can load batch
files, but the disadvantage that loading requires miminum
memoryof 32K ~dash~ enough to load COMMAND.COM. and a program of
up to about 25-27K.

~Subhead~ When DESQview Loads a Program

 DESQview can bypass COMMAND.COM and load a program directly
~dash~ but not a batch file. If you want DESQview to load the
program, rather than DOS:

~Item~ Enter the program name as Program.EXE or Program.COM,
rather than just Program ~dash~ for example, 123.EXE. (Lotus 123
is usually automatically installed and uses a DESQview loader
~dash~ which fills in Lotus.EXE for you.)

~Item~ Turn ON (Y) the Close on exit option.

 Letting DESQview load the program instead of DOS, has the
advantage that you can load programs as small as 1K, rather than
32K. The Close on exit option must be turned ON because there
won't be any command processor available to accept your commands
when the program terminates.

~Subhead~ When a Program Has a Custom DESQview Loader

 When a program has a special DESQview "loader", the Program
field contains the command to start up the "loader"
(L:\LoadDir\xx- LOAD.COM) and the Parameters field contains the
command to start up the program plus any program parameters
(P:\ProgDir\Program.EXT Parameters) ~dash~ where xx-LOAD.COM is
the name of the "loader" for the program. Usually, L:\LoadDir is
C:\DV ~dash~ but it doesn't have to be. The program extension,
.EXT, must be specified.

The Program and Directory fields are set up for you automatically
when you install the program, so normally you don't have to
concern yourself about "loaders."

~Subhead~ When a Program is Loaded from a Batch File

 You can also enter the name of a batch file in the Program
field. Normally, when you run a program (or programs) from a
batch file, you should turn OFF the Close on exit option. If this
option is ON, the window will close automatically after running
the first program in the batch file. To close the window on
finishing the batch file, put EXIT as its last command. (If the
batch file runs only one program, and it's the last command in
the file, you can leave Close on exit ON.)

Set Memory Size (in K) for a batch file to the size of the
largest program plus any TSRs your batch loads and 7K for DOS
COMMAND.COM.

~Begin footnote~

Certain versions or brands of DOS may require less than 7K.

~ End footnote~

 The minimum memory size for a batch loader is 32K.

~Subhead~ Creating a DOS Window

 To create a DOS window, leave the Program field empty, or enter
a DOS command ~dash~ for example, PROMPT. If you enter a DOS
command, be sure to put the parameters in the Parameters field
and not in the Program field.

~Subhead~ When a Program is Full-Screen-Only

 There are two types of programs: those that can run in small
windows (and in background) and those that can't, and therefore
run full-screen-only:

 The  Writes text directly to screen option specifies, when ON,
that the program writes  directly to the screen and, therefore,
requires the entire screen  when it's running. It cannot run in a
small window unless you  are running on a 80386 with QEMM-386 and
the option, Virtualize text/graphics  , is ON. See the following
page for a short discussion of Virtualization  and Appendix K for
more information. To find out whether a program writes directly
to the screen, turn this option OFF and run the program in a
small window. If any program information appears outside the
window boundaries, it writes directly to the screen, so you must
turn this option back ON. All graphics based programs write
directly to the screen.

~Subhead~ When a Program is Copy-Protected

 If a program is started from a copy-protected diskette, you can
have DESQview remind you to load the diskette:

 The Requires floppy diskette option specifies, when ON, that the
program resides  on a floppy diskette. When you start up the
program, DESQview will  remind you to put the program diskette in
the floppy drive.

~Subhead~ When a Program Uses Serial Ports

 The Uses serial ports  (Y, N, 1, 2) option tells DESQview which,
if any, serial ports  the program will use. Selecting 1 indicates
COM1, selecting 2 indicates  COM2, selecting Yes (Y) means all
ports, selecting No (N) means no  serial ports will be used by
that program. You may not leave this  option blank.  DESQview
will only allow a program access to those ports that it is
configured to use. This reduces the conflicts between two
communications  programs running at the same time.  If you enter
Y to specify ALL ports, DESQview will allow a program  to
additionally access serial ports 3 or 4if you have these
additional ports. In addition, DESQview's Auto Dialer feature
lets you select them for your modem.

~Subhead~ Taking Advantage of an 80386 or i486 Processor.

 DESQview 386 is the combination of DESQview plus QEMM-386 (the
Quarterdeck Expanded Memory Manager-386). This combination offers
features not possible with any other configuration.

 When running DESQview 386 on an 80386 or i486 PC, text, a CGA,
Hercules, EGA or VGA programs can run in a "small window,"even
when not "well-behaved". DESQview's ability to run most

~Begin footnote~

Programs that run in video modes beyond the VGA standard, such as
hi-res 256 color or hi-res 800 x 600 mode mode, cannot be
virtualized. Also, programs running in 40 column text mode cannot
be virtualized.

~End footnote~

 programs in small windows is accomplished by "virtualization."
With virtualization ON, DESQview 386 automatically intercepts the
video output of programs which write directly to the screen and
manages the screen data itself. Since this uses more exPANDed
memory, for performance reasons, you can control which programs
DESQview 386 virtualizes.

 The Virtualize text/graphics (Y,  N, T) option specifies, when
ON (Y), that DESQview should  keep the program from writing
directly to the screen under all circumstances.  The program can
then display its information in a DESQview window  and run in
background because DESQview is managing the program and  the
portion of the video output that displays in the window.

~dash~  When you specify No (OFF), DESQview's action is dependent upon
how you set the Writes text directly to screen option. If your
program writes directly to the screen, DESQview will not run your
program in a small window. If your program does not write
directly to the screen, DESQview will run the program in a small
window.

 ~dash~  When you specify (T), for text only, DESQview will only
virtualize the screen when your program is in text mode. If your
program switches from text mode to graphics mode, the screen
virtualization will stop. This option allows a program to run in
a small window when in text mode, but use the screen directly
when in graphics mode.

 ~dash~  Text mode virtualization causes very little performance
degradation, whereas graphics virtualization can affect
performance considerably ~dash~ especially on EGA displays, so
you would not want to use this option unnecessarily.

 ~dash~  For a character based program (text program) like Lotus
1-2-3, (versions 1 and 2) use a DESQview loader whenever
available, and don't virtualize. The loader file will contain all
information necessary to run the program in a small window and in
background. For a graphics program, set virtualization ON, and
don't use a loader. Also, see Appendix K, More About Virtualization.

 The Share EGA when foreground/zoomed option specifies, when Yes
(Y), for DESQview to allow  other EGA graphics programs to run in
background. If you enter no  (N) to Share the EGA, DESQview will
freeze EGA programs running in  background when your program is
zoomed to a full screen window. If  you enter yes (Y), all EGA
programs which are currently open in DESQview  windows will run
more slowly.

~dash~  If you want maximum performance in your
foreground graphics program, you do not want other programs to be
sharing your EGA hardware.

 ~dash~  You can dynamically change this option, using DESQview's
Tune Performance command. Setting it here makes it the default
start-up mode of the program.

 The Protection Level (0-3) option allows you to specify a
protection level, if  one is needed.  DESQview uses the 80386
processor's protection capabilities to give  you protection
against misbehaved programs. Protection can result  in some
degradation of your program's performance.  DESQview will
exercise more protection  the higher the protection level
selected. Selecting 0 tells DESQview  not to set up any special
protection around your program. If you know  your program is
reliable and works without crashing, we strongly suggest  that
you do not set up any protection. If DESQview 386 detects that
the program is trying to do something which might damage
DESQview,  DOS, or other programs, DESQview will post an error
message (prior  to the damage being done) describing in technical
terms the action  that seemed dangerous. You may then abort the
program, or turn off  DESQview's protection and let the program
proceed on its dangerous  course. Sometimes you will be given a
third option, of allowing this  one violation to occur, but
keeping the protection in place to detect  further violations.
Typically, you should abort the program if you get a protection
violation.  Then, try increasing the memory size for the program
and try it again.  If the violation no longer occurs, then the
program probably required  more memory than you had previously
given it, but it failed to detect  that it had insufficient
memory. You might want to inform the program  developer of this.
If the protection violations continue, then perhaps the program
has a bug in it, or perhaps it is doing something which, although
potentially dangerous, is really all right. You can try lowering
the protection level (or setting it to 0) and hope for the best.

~Heading~ Allocating the Memory for a Program

 You must supply DESQview information about how much memory a
program requires:

 The Memory Size (in K) field specifies the minimum amount  of
memory the program needs. Normally, this is the minimum amount
of memory needed to run the program. However, for very small
programs  (under 32K), you must take into account the method used
to load the  program. If DOS loads the program the minimum memory
size is 32K.  If DESQview loads the program, the minimum size is
1K.

In addition to the memory for the program itself,  DESQview
allocates approximately 2K to manage the program, 1K for  a
script buffer, and 4K to store the contents of the screena  total
of about 7K. If the Displays graphics information option  is ON
(see below), this value may increase by 12K (to 19K), depending
on the type of display adapter you have on your system.

Many programs will use memory over the minimum you allocate to store
more program data. So, you may want to increase this default
size in such cases. Also, some programs that store data in
exPANDed  memory require more than the default size to take
advantage of this feature for example, Framework III. See
Appendix E for information on determining a program's memory
requirements.

When a special DESQview "loader" is used to load the program, its
size (2K-5K) is already included in the default memory size supplied
in the program's DVP.

~Subhead~ Working with a Graphics Program

 If the program ever displays graphics information on the screen,
you must tell DESQview so it can reserve extra memory ~dash~
because it takes more memory to save a graphics screen than it
does to save a text screen.

 The Displays graphics information option specifies, when ON,
that the program displays  some or all of its information as
graphics.

~Subhead~ Controlling Whether a Program Can Be Swapped

 When you try to start up a program, but there's not enough
memory to load it, DESQview tries to swap out one or more
programs to free up the memory it needs. You can control whether
a program should be swapped out:

 The Can be swapped out of memory  (Y,N, Blank) option specifies,
when ON, that the program can be  swapped out of memory to disk,
RAM disk, or exPANDed memory when DESQview  needs memory to load
a new program. This allows DESQview to have more  windows open
than can fit in your PC's memory. Most programs can be swapped to
disk. The major exception is communications programs.
Communications programs should ususally have this option turned
OFF

~dash~ because they must remain in memory at all times to
manage the communications line. However, in certain instances,
they can be swappable. See page 210.

~Item~ If you leave this option blank, DESQview will decide
whether or not to swap based on the settings of other options.

~Heading~ More About Allocating Memory

 This section is intended to provide the information that an
advanced user or program developer needs to configure a program
more precisely for DESQview. It's not necessary for you to read
or understand this information to install or use a program in
DESQview.

~Subhead~ An Overview

 In addition to a minimum memory size, you can specify a maximum
memory size:

 The Maximum Program Memory  Size (in K) field specifies the
maximum amount of memory to ever  allocate to the program.
Normally, this field is empty. If you specify  a maximum program
size, it means that DESQview should allocate as  much memory as
it can to the programbut no less than the minimum  and no more
than the maximum.  The amount of memory the  program actually
gets will depend on the configuration of your programs  and
windows at the time you start up the program. The method DESQview
uses to allocate memory is:

First, DESQview determines how much memory it has available to load
a program:

~Item~ The largest available contiguous area of program memory
(in the 0K- 640K area) is calculated.

~Item~ If you have EMS4 or EEMS memory, the amount of unused
EMS4/EEMS memory is calculated.

Then, using these values, DESQview determines if it's possible to
supply at least the minimum amount of memory the program requires
from your existing memory configuration.

If enough memory exists to load the program, DESQview then
determines the actual amount of memory to allocate by examining
the Maximum Program Size (in K) field:

~Item~ If this field is empty, DESQview allocates exactly the
minimum amount of memory requested.

~Item~ If this field specifies a value (larger than the minimum),
the program is allocated all the memory now available, up to the
maximum specified.

If there isn't enough memory available to load the program,
DESQview swaps out one or more programs (if possible) until it
has freed up at least the minimum amount of memory needed:

~Item~ If DESQview succeeds, the program is loaded according to
the preceding step.

~Item~ If DESQview fails, the program cannot be loaded ~dash~ see
Appendices E and F.

 The memory freed up by swapping out programs may be either
program memory or EMS4/EEMS memory (if you have EMS4 or EEMS
memory)

~dash~ depending on what programs were swapped out.

~Subhead~ Allocating System Memory for a Program

 The sizes specified in the Memory Size (in K) and Maximum
Program Memory Size (in K) fields only control how memory is
allocated to the program itself. DESQview also requires memory to
manage the program. This area (about 2K) is automatically
allocated in addition to the program memory. Sometimes, however,
you need more "system" memory than this:

 The System Memory (in K) field specifies the amount of
additional system  memory to set aside for the program. This
value should be zero unless  the program was written expressly
for DESQviewsuch as built-in  DESQview programs and DESQview
Companionsor unless you want to force the graphics screen
to be saved in program memory. Included in the
automatically allocated area is room to save the interrupt
vectors and the coprocessor status information:

 The Interrupts fields specify the range of interrupts to
save normally 00H to FFH. Reducing this range both saves memory
and reduces (very slightly) the time required to switch between
programs. However, do not change these values unless you're
absolutely sure you know the correct values. As a rule, only the
program developer should change these values. The Uses math
coprocessor option specifies, when ON, that DESQview should set
aside additonal system memory for the information needed to
manage the coprocessor chip. Leaving this option OFF when the
program doesn't  use it, both saves memory and reduces (very
slightly) the time required to switch between programs. This
setting has no effect on whether the program can use the
coprocessor. That's up to the program.

Subhead~ Allocating Screen Memory for a Program

DESQview also requires additional memory to save what's on the
screen:

The Text Pages field specifies the amount of memory to set aside
for the information on your screen when the program is operating
in text mode but in pages not K (see below). This text screen
area is where you screen's contents are stored when you switch
away from the program or while the program is running in a small
window.

The Graphics Pages field specifies the amount of memory
to set aside for the information on your screen when the program
is operating in graphics mode also in pages. This graphics screen
area is where you screen's contents are stored when you switch
away from the program.

The Displays graphics information option is a shortcut for setting
Graphics Pages.  When you turn this option ON, Graphics pages is set
to 1 (or to the last nonzero value you entered previously). When you
turn this option OFF, Graphics Pages is set to zero.

Information that appears on your video display screen is written
there by your display adapter board, in one of two ways: as text
or as graphics. All display adapters can display text. Only some
can display graphics as well.

Normally, a display adapter only displays one screen's worth of
information, since that's all you can see. However, some display
adapters can maintain several screens' worth of information at one
Time and switch instantly between them. When a display adapter does
this, each screens's worth is called a page. The size of a page
varies from as little as 4K to as much as 128K. And, since some display
adapters  support multiple graphics pages, the total graphics screen
that DESQview must manage can be quite largeup to 256K in size.

~Subhead~ Allocating Memory for "Text Pages"

 "Text screen" memory is the area of memory in which all the
program's "text pages" are saved ~dash~ and is always allocated
out of the program memory area. Its size varies according to the
type of display adapter you're using and the mode it's operating
in, as shown in the table on the following page.

 Memory Allocation for a "Text Screen"

~Begin Table~

Number of Text Pages. Hercules(25x80), CGA(25x80), EGA/VGA(25-
line mode), VGA(30-line-mode), EGA/VGA(43-line mode), VGA(50-
line-mode), VGA(60-line-mode)


1, 4K, 4K, 4K, 5K, 7K, 8K, 10K

2, 8K, 8K, 8K, 10K, 14K, 16K, 19K

3, 12K, 12K, 12K, 15K, 21K, 24K, 29K

4, 16K, 16K, 16K, 19K, 27K, 32K, 38K

~End Table~

Unless you're sure the program uses multiple "text pages" (almost
none do ~dash~ the only significant exception being BASIC), leave
Text Pages set to 1 ~dash~ its normal default value. Otherwise,
set it to the number of "text pages" the program uses.

When you have a program that's written expressly for DESQview,
and Text Pages is set to 1, DESQview may allocate less space than
indicated in the table because, in such cases, DESQview allocates
only the amount of memory required to hold the largest screen
that the program can display ~dash~ namely, twice the product of
Maximum Height and Maximum Width (see page 127). For example, if
the maximum height/width is specified as 10,60, DESQview would
allocate about 1,200 bytes (2x10x60) rather than 4K. (When Text
Pages is 2 or more, DESQview always allocates the amount of
memory indicated in the table.)

~Subhead~ Allocating Memory for "Graphics Pages"

 "Graphics screen" memory is the area of memory in which all the
program's "graphics pages" are saved. Its size varies according
to the type of display adapter you're using and the mode it's
operating in. Determining the amount of memory allocated to a
"graphics screen" is more complicated than for a "text screen"
~dash~ because its size can vary dynamically (as the program
runs) from 16K to 256K. To accommodate this, DESQview tries to
save "graphics screens" in exPANDed memory:

~Item~ If exPANDed memory exists and enough is available to save
the "graphics screen," DESQview uses exPANDed memory. In this
case, the full graphics image remains on the screen even when you
switch away from the program ~dash~ and thus can be viewed
simultaneously with other windows (for most EGA and VGA modes),
even though the program isn't running.

~Item~ If exPANDed memory doesn't exist or enough isn't
available, when you switch away from the program, a "graphics
curtain" is drawn over the screen and the "graphics screen" is
swapped out to RAM disk or hard disk.

If you don't have exPANDed memory, and you want the "graphics
screen" stored in program memory, set System Memory (in K) large
enough to hold the largest "graphics screen" the program can ever
have. (There is no value in taking this approach if you do have
exPANDed memory.)

The table below shows the range of memory sizes that a "graphics
page" can have. Although Hercules and CGA display adapters have
several modes, DESQview always allocates 64K to a Hercules
display adapter and 16K to a CGA display adapter. EGAs and VGAs,
however, have a wider range of modes which programs can switch
between. DESQview accommodates such behavior by managing EGA and
VGA memory dynamically ~dash~ that is, by adapting to the
changing behavior of the program rather than permanently
allocating a fixed-size area (unless you've allocated the
"graphics screen" in program memory).

 Memory Allocation for a "Graphics Screen"

Number of Graphics pages   Program Memory Allocated
 Hercules(graphics mode), CGA~dagger~(graphics mode), EGA/VGA
(medium resolution), EGA/VGA(high resolution)

1, 64K, 16K, 64K, 128K

2, 64K,  N/A, 128K, 256K

~End Table~

~Table Note~   All sizes in this table are approximate.

~Begin footnote~

Includes EGAs when operating in CGA-compatibility mode.

~End footnote~

If the program doesn't use graphics, set Graphics Pages to zero
or turn OFF the Displays graphics information option (both of
which have the same effect). If the program does use graphics,
set Graphics Pages to 1 or turn ON the Displays graphics
information option (both of which have the same effect). Don't
set Graphics pages to 2 unless you're absolutely sure the program
uses two "graphics pages".

The value in Graphics Pages (or the setting of the Displays
graphics information option) only affects whether the screen is
properly saved and restored when you switch away to another
program and then switch back. So, if you have a program that
displays graphics information, but you don't want to save it when
you switch away, just set Graphics Pages to zero (or turn OFF the
Displays graphics information option). This is especially useful
for programs that can quickly redraw their graphics information
~dash~ such as Lotus 1-2-3.

~Subhead~ Allocating a Scripts Buffer for a Program

 DESQview requires memory to save a program's scripts ~dash~ if
any:

 The Script Buffer Size field specifies the amount of memory to
set aside for the Program Scripts buffer (see page , page , and
Appendix A). The default is 1K, which is generally enough for 20
or more routine scripts.

~Subhead~ Managing Howa Program UsesExpanded Memory

 DESQview supports EMS 3.2 , EMS4 exPANDed memory and enhanced
exPANDed (EEMS) memory. EMS memory can only be used as data
storage ~dash~ for programs that explicitly know about and use
EMS memory for data (such as 1-2-3 Release 2, FrameworkIII, and
so forth) or as a "swapping" area.

Some programs that use exPANDed memory to store data immediately
grab all available exPANDed memory when they start up. Once a
program takes exPANDed memory for itself, it can't be used for
other purposes, until the program gives it back ~dash~ which,
most likely, won't happen until you close it down. To solve this
problem, you can limit a program's exPANDed memory:

~Heading~ Controlling a Program's Behavior

 DESQview allows you to control many aspects of a program's
behavior.

~Subhead~ Controlling a Program's Appearance

 You can control a program's appearance on the screen:

 The Initial Mode field is normally blankmeaning that,
when DESQview starts up or switches to the program, it should
display the program in whatever mode DESQview is in at the
time, if possible. You may, if necessary, specify the hardware
video mode (in hex) that DESQview should switch to when the
program starts up or when it becomes the current (foreground)
program (see table). This is primarily of use to program
developers, except:

~dash~  On a CGA, you can force a program to switch to color by
setting Inital Mode to 3

~dash~ which is especially useful if you normally run programs in mode 6.

 ~dash~  If you have certain brands of Hercules-compatible
display adapters, which don't let you detect their mode, you can
set Initial Mode to the mode the program uses.  (Otherwise, in
such cases you must load DVHERC.COM ~dash~ see Appendix G.)

 ~dash~  If you have two displays, you can force a program to run
on the one DESQview isn't running on (the alternate monitor). The
alternate monitor can only run multiple applications in full
screen  mode (no small windows).

 ~dash~  If are using two displays, the Initial Mode should
specify the video mode for the monitor you use when you start
DESQview (the DESQview monitor). If you start DESQview from a
monochrome monitor, and you want to use the CGA, VGA or EGA
monitor as the alternate monitor, set initial mode to 3.

 ~dash~   Conversely, if you start DESQview on a CGA, VGA or EGA
monitor, and want to switch to the monochrome monitor, set
Initial Mode to 7.

Begin Table

Basic Video Modes

Initial Mode ~footnote1~ (in hex)
Type
Resolution ~footnote2~
Color or Black and White ~footnote3~


0,1,  ~dash~ ,  ~dash~ ,  ~dash~

2, Text, 25x80, B&W

3, Text, 25x80, Color

4, Graphics, 200x320, Color

5, Graphics, 200x320, Color

6, Graphics, 200x640, B&W

7, Text, 25x80, Monochrome

8-20, Graphics, Various, Both

21, Graphics, 348x720, B&W

22, Graphics, 347x720, B&W

~End Table~

~footnote1~ Modes 7 to 20 are EGA/VGA graphics modes--refer to your
EGA or VGA technical manual for more information. Modes 21 and 22
only apply to a Hercules display adapter. 21 selects graphics
page 1 and 22 selects page 2.

 DESQview tries to avoid switching video modes. So, when you tap
the DESQ key, DESQview tries to display the DESQview menu in the
mode the current window is in. (This may result in the DESQview
menu appearing in black and white or may cause the screen to
change color palettes--see Appendix A.) If this isn't
possible, DESQview draws the "graphics curtan" over the current
window, then switches to a mode in which it can display the
DESQview menu. Similarly, if you switch between programs in
incompatible modes, DESQview curtains the one you switch away
from.

~footnote2~ The resolution of text modes 2 and 3 may be higher than 25x80
if you have an EGA or VGA DISPLAY adapter. EGAs can display 25x80
or 43x80 in these modes. VGAs can display 25x80, 30x80, 50x80,
and 60x80. See page 122.

~footnote3~ "B&W" indicates that information is being displayed in
monochrome on a color display. "Monochrome" indicates that a
monochrome display is being used.

 The Uses its own colors option specifies, when ON, that the
program has its own color scheme and that you wish to use this
color scheme instead of the window colors that DESQview normally
provides for the windowsee Appendix A. DESQview (logically)
forces this option to ON if the Writes directly to screen option
is ON. For more information on Uses its own colors, please see
page.

~Subhead~ Controlling a Program Window's Size and Position

 You can control the program window's size and position by
filling in the Window Position fields:

 The Maximum Height/Width fields specify the maximum height and
width that the window can ever have. Unless the program is well
behaved (see page ) or written expressly for DESQview, the
maximum height/width should not be set to less than 25,80. (If
the program runs only in graphics video modes, and never uses
text modes, set the maximum height/width to 0,30 to save screen
memorysee pages -).

The Starting Row/Column/Height/Width fields
specify the initial position on the screen where the window for
the program should be placed, and its height and width. Row and
Column specify the position of the top-left corner of the window
(excluding its frame, if any). You may set Starting Height to the
number of lines desired for text modes of EGA or VGA adapters.
Setting this value will cause DESQview to switch the screen to
the proper mode when the window is opened, as well as when you
switch back to it. For programs with Writes Directly to Screen
set OFF, you must also set Uses its own colors ON. Both Starting
Height and Maximum Height should be set to 43 for EGA and 50 for
VGA. These are the only currently supported values. ~Item~ If
these fields are left empty, the window is assigned one of the
nine predefined window positions (see page 52 and Appendix A)

 Row and column offsets are counted from 0. So, the top-left
corner of the screen is 0,0. There are two types of windows:

~Item~ A full-screen window must start at 0,0. The standard full-
screen windows are 0,0,25,80 for a 25x80 window; 0,0,43,80 for a
43x80 window, and so forth.

~Item~ A small window must start at 1,1 or greater, and have a
height and width that allow room for a frame. On a 25x80 screen,
the largest "small" window is therefore 1,1,23,78, and so forth.

 Programs written expressly for DESQview may create multiple
windows, override the window position settings you specify, or
create windows without frames. When a program has multiple
windows, the Window Position settings apply to the main (task)
window. If the main window is a "small" window, but has no frame,
it may be positioned at 0,0.

~Subhead~ Using a Shared Program

 A shared program is a program written expressly for DESQview
that can be used by several other programs simultaneously:

 The Shared Program Pathname field specifies the DOS file
containing the shared program. The Shared Program Data field
specifies data to be sent to the shared program. These fields are
primarily for use by program developers. You cannot load a
standard, off-the-shelf-program as a shared program. Leave these
fields empty unless you have a program that explicitly instructs
you to use them.

~Subhead~ Controlling How a Program is Closed Down

 You can control how a program is closed down:

 The Allow Close Window command option specifies, when ON, that
the program can be closed down using the Close Window menu. If
this option is OFF, the program can only be closed down by
performing the program's quit command. Furthermore, the DESQview
Quit command won't be available as long as any program that has
this option is set to ON is running. (This prevents accidentally
closing the program or quitting DESQview.) The Close on exit
option specifies, when ON, that when the program running in the
window returns control to DOSusually as a result of your
performing the program's quit commandDESQview should
automatically perform the Close Window command. If this option is
OFF, when you perform the program's quit command, control returns
to DOS and the DOS prompt appears. ~Item~ If this option is left
blank, DESQview will decide whether or not to close the window on
exit based on the following criteria:

 ~dash~  If the program was loaded by DESQview the window will
close on exit.

 ~dash~  If the program was loaded by DOS the window will not
close on exit.

 See Controlling How a Program is Loaded, page 115.

~Subhead~ Controlling Whether a Program does Background Processing

 You can control whether or not a DESQview should try to let a
program run in background when you switch away from it.

 The Runs in background (Y,N, blank) option specifies whether the
program can continue to run in background when you switch away
from it. By default, this option is set to blank which indicates
that DESQview should decide when the program will be permitted to
run in background and when it won't. You can explicitly turn this
option ON or OFF, if you want.

It's usually best to leave this
option blank. How DESQview determines whether or not to run a
program in background is somewhat hardware/software dependent:
DESQview can usually tell whether a program is actively
processing/polling for inputor just waiting aroundand adjust time
slicing accordingly. In addition, the way a program writes to the
screen and whether or not you are running on a 80386 affects
background processing when you switch away from a window:

~dash~ If you are running on a 80386 with QEMM-386 and a program that
writes directly to the screen is virtualized, DESQview will allow
it to run in the background when you switch away from that
window.

 ~dash~  If you are not running on a 80386 with QEMM-386 and the
Writes text directly to screen option for the program is set ON,
or the program is displaying graphics information, DESQview will
freeze the program when you switch away from it.

Unless Runs in background is explicitly set OFF, the program will
always run in the background if Writes text directly to screen is
set OFF.

There is another parameter you can enter in the Runs in
Background field, D. If you enter D, the program will run in
background except when any DOS calls are being made. This is a
seldom-used option that is useful mainly for stabilizing certain
terminal emulation programs. If you enter D, it can result in the
program not running in background most of the time, depending on
what the foreground ~dash~ and other windows running in
background ~dash~ are doing at the DOS level.

 The settings for background processing you make here may be
temporarily overriden from the Tune Performance options available
from the Rearrange menu. See page 54.

~Subhead~ Sharing the Processor

 If you want maximum performance in your foreground program, you
do not want other programs to be running in background.

 The Share CPU when foreground option specifies, when Yes (Y),
that you allow other programs to run in background when this
program is executing in the foreground. If you enter No (N) to
Share CPU when foreground, DESQview will freeze all programs
running in background when the foreground program is executing.
When the foreground program is not executing (for example,
waiting for a keyboard character), then background programs will
be allowed to run. You can dynamically change this option, using
DESQview's Tune Performance command (See page 54).

~Subhead~ Using a Program's Colors

 You can control how DESQview displays a program in a window. The
Uses its own colors option controls how certain aspects of the
screen display are managed. If set to No (N), changes to the
screen such as character set (font) or palette are disregarded.
(They are logically remembered by the program, but not allowed to
occur.) If set to Yes (Y), the font or palette changes the
program makes are allowed and will take effect.

 The Uses its own colors option specifies, when ON, that the
program has its own color scheme and that you wish to use this
color scheme instead of the one that DESQview normally provides
for the window (See Appendix A ). The DESQview color scheme uses
the standard IBM palette. If, outside of DESQview, you like the
colors your program uses, you should select Yes (Y) for the Uses
its own colors option. If you'd like DESQview to display your
program using colors from the DESQview palette, then you should
select No (N).

~dash~  Graphics programs often have their own
palette. So that your graphics program has the same look and feel
outside and inside DESQview, DESQview will use the palette of
your graphics program when the program is zoomed to full screen.

 ~dash~  As you run multiple graphics programs in small windows
in DESQview 386, you will notice that your programs often change
colors ~dash~ when you bring up the DESQview menu or when you
switch windows. The reason is that DESQview sets the entire
display according to the palette specified by the foreground
program.

 ~dash~  Two graphics programs, with palettes different from the
IBM palette, are Microsoft Windows and Digital Research's GEM.
Not only have these two programs redefined the palette ~dash~ but
you'll notice that when you have Ventura Publisher (a GEM
program) and Microsoft Excel (a Windows program) on the screen at
the same time in small windows, switching to Excel will cause
Ventura to change from black characters on a white background to
white colors on a black background.

 ~dash~  If you find that the graphics programs in background
windows are unreadable or you are bothered by the colors, you can
fine-tune the colors of DESQview's palette and menus.

~Subhead~ Using the DESQview Palette Program

 To fine-tune the colors of your program and of DESQview menus,
you have the following DESQview tools:

 ~dash~  The DESQview Palette program (DVPAL.COM) is included on
your DESQview diskette. This program lets you change the palette
for DESQview menus and those used by programs with Uses it own
colors set to No. Begin footnote
You will have to add DESQview Palette to DESQview's Open Window
menu using the Add a Program command.
End footnote

 ~dash~  Using DESQview Palette, you can create your own palette
by choosing the intensity of blue, green and red in each color of
the palette, restore the original DESQview palette, make the
DESQview palette the same as the GEM or Windows palette, load and
save palettes, and set blinking on or off.

~Begin footnote~

Before using DESQview Palette, use Change a Program to set the
Uses it own colors option to No and the Virtualize text/graphics
to Yes for the graphics programs whose colors you wish to change.
Then open these graphics programs and put them in small windows
so that you can see how their colors change as you change the
palette.

~End footnote~

 ~dash~  You may save your personal palette to the default
filename, DVSETUP.DV and it will be loaded each time you start
DESQview.

 ~dash~  DESQview Setup, Advanced Option, Colors lets you change
the color scheme of each text window displayed using the DESQview
palette and change the color scheme of DESQview's menus.

See page 57 for additional usage information for DESQview
Palette.

If you change the DESQview palette , so that it is the same as
Microsoft Window's palette, DESQview's menus will turn red. You
can make these DESQview menus blue again by using the Colors
option in DESQview Setup.

~Subhead~ Controlling How Keys Are Sent to a Program

 You can control how keys are sent to the program. DESQview has a
128-character buffer where it stores each key you type ~dash~ or
each key that's played back by a script or transferred by the
Transfer command.

 The Keyboard conflict (0-F) option controls how DESQview manages
this buffer and sends keys to the program.Unless you are the
program's developer, the only way to determine the proper level
for a program is to experiment. Set the level to 0 and play back
a long script or transfer a large block of information. If
keystrokes are dropped, enter a different value and try again.
There are 16 possible values for this setting: 0 is the default
setting. It allows DESQview to buffer keys to maintain rapid
type-ahead and present them to the application in a manner that
best supports DESQview's macros and mark and transfer features.
1, 2 and 3. These values modify the way DESQview manages keyboard
input to the application. Keystrokes are still buffered, but the
rate at which they are sent (and other characteristics) are
changed. 4. instructs DESQview to not buffer keystrokes and to
modify its behavior somewhat when switching away from an
application.

~dash~  The important idea with respect to keyboard
conflict 4 is that it should be used with applications which
obtain their keyboard input directly from the BIOS data area
keyboard buffer. A significant symptom of the need for this
keyboard conflict setting is a background application which
appears to be getting the foreground application's keystrokes, or
keyboard input which seems to be "created" for you.

 ~dash~  This setting also works in conjunction with Advanced
Setup: Keyboard's maintain shift state option in the following
way. If you have instructed DESQview to maintain shift states,
then for each application with keyboard conflict 4 set (or its
variations), DESQview will save and restore the full BIOS
keyboard buffer.

5, 6 and 7. These values combine the keyboard management of
keyboard conflict 4 with those of keyboard conflicts 1, 2 and 3
respectively.

8. Some 3270 and 5250 emulation programs and ill-behaved "pop-
ups" are known to be helped with this setting. An undesirable
side-effect of this setting is that keystrokes may occasionally
be lost. Your need for the program that may be helped by this
setting will have to be balanced against this side-effect.

9, A and B. These values combine the keyboard management of
keyboard conflict 8 with those of keyboard conflicts 1, 2 and 3
respectively.

C. This keyboard conflict setting combines the effects of
settings 4 and 8.

D, E and F. These values combine the keyboard management of
keyboard conflict 4 and 8 with those of keyboard conflicts 1, 2
and 3 respectively.

 Also see Appendix H.